"""
历史记录管理模块
提供摘要历史记录的保存、加载和管理功能
"""

import os
import json
import time
from typing import List, Dict, Any, Optional, Union
from datetime import datetime
from .config import get_config

class History:
    """历史记录管理类"""
    
    def __init__(self, history_file: str = "history.json"):
        """
        初始化历史记录管理类
        
        Args:
            history_file: 历史记录文件路径
        """
        self.history_file = history_file
        self.history: List[Dict[str, Any]] = []
        self.auto_save = get_config("历史.自动保存", True)
        self.max_count = get_config("历史.最大数量", 100)
        
        # 加载历史记录
        self._load_history()
    
    def _load_history(self) -> None:
        """加载历史记录文件"""
        if os.path.exists(self.history_file):
            try:
                with open(self.history_file, 'r', encoding='utf-8') as f:
                    self.history = json.load(f)
            except Exception as e:
                print(f"Error loading history file: {str(e)}")
                self.history = []
        else:
            self.history = []
    
    def _save_history(self) -> bool:
        """
        保存历史记录到文件
        
        Returns:
            bool: 是否保存成功
        """
        try:
            # 确保目录存在
            os.makedirs(os.path.dirname(os.path.abspath(self.history_file)), exist_ok=True)
            
            # 写入历史记录
            with open(self.history_file, 'w', encoding='utf-8') as f:
                json.dump(self.history, f, ensure_ascii=False, indent=4)
            return True
        except Exception as e:
            print(f"Error saving history file: {str(e)}")
            return False
    
    def add_record(self, original_text: str, summary: str, keywords: List[str], ratio: float, source: str = "text") -> str:
        """
        添加历史记录
        
        Args:
            original_text: 原始文本
            summary: 摘要文本
            keywords: 关键词列表
            ratio: 摘要比例
            source: 文本来源（"text"、"file"等）
            
        Returns:
            str: 记录ID
        """
        # 生成记录ID
        record_id = str(int(time.time() * 1000))
        
        # 创建记录
        record = {
            "id": record_id,
            "timestamp": datetime.now().isoformat(),
            "original_text": original_text,
            "summary": summary,
            "keywords": keywords,
            "ratio": ratio,
            "source": source
        }
        
        # 添加到历史记录
        self.history.append(record)
        
        # 如果超过最大数量，删除最早的记录
        while len(self.history) > self.max_count:
            self.history.pop(0)
        
        # 如果启用自动保存，保存历史记录
        if self.auto_save:
            self._save_history()
        
        return record_id
    
    def get_record(self, record_id: str) -> Optional[Dict[str, Any]]:
        """
        获取指定ID的历史记录
        
        Args:
            record_id: 记录ID
            
        Returns:
            Optional[Dict[str, Any]]: 历史记录，如果不存在则返回None
        """
        for record in self.history:
            if record["id"] == record_id:
                return record
        return None
    
    def get_all_records(self) -> List[Dict[str, Any]]:
        """
        获取所有历史记录
        
        Returns:
            List[Dict[str, Any]]: 历史记录列表
        """
        return self.history
    
    def delete_record(self, record_id: str) -> bool:
        """
        删除指定ID的历史记录
        
        Args:
            record_id: 记录ID
            
        Returns:
            bool: 是否删除成功
        """
        for i, record in enumerate(self.history):
            if record["id"] == record_id:
                self.history.pop(i)
                
                # 如果启用自动保存，保存历史记录
                if self.auto_save:
                    self._save_history()
                
                return True
        return False
    
    def clear_history(self) -> bool:
        """
        清空历史记录
        
        Returns:
            bool: 是否清空成功
        """
        self.history = []
        
        # 如果启用自动保存，保存历史记录
        if self.auto_save:
            self._save_history()
        
        return True
    
    def search_history(self, query: str) -> List[Dict[str, Any]]:
        """
        搜索历史记录
        
        Args:
            query: 搜索关键词
            
        Returns:
            List[Dict[str, Any]]: 匹配的历史记录列表
        """
        if not query:
            return self.history
        
        query = query.lower()
        results = []
        
        for record in self.history:
            # 在原文、摘要和关键词中搜索
            if (query in record["original_text"].lower() or
                query in record["summary"].lower() or
                any(query in keyword.lower() for keyword in record["keywords"])):
                results.append(record)
        
        return results
    
    def export_history(self) -> Dict[str, Any]:
        """
        导出历史记录
        
        Returns:
            Dict[str, Any]: 包含历史记录和元数据的字典
        """
        return {
            "version": "1.0",
            "timestamp": datetime.now().isoformat(),
            "records": self.history
        }
    
    def import_history(self, data: Dict[str, Any], merge: bool = True) -> bool:
        """
        导入历史记录
        
        Args:
            data: 历史记录数据
            merge: 是否合并现有记录，False则替换
            
        Returns:
            bool: 是否导入成功
        """
        try:
            # 验证数据格式
            if "records" not in data or not isinstance(data["records"], list):
                return False
            
            if merge:
                # 合并记录
                existing_ids = {record["id"] for record in self.history}
                for record in data["records"]:
                    if "id" in record and record["id"] not in existing_ids:
                        self.history.append(record)
                        existing_ids.add(record["id"])
            else:
                # 替换记录
                self.history = data["records"]
            
            # 如果超过最大数量，删除最早的记录
            while len(self.history) > self.max_count:
                self.history.pop(0)
            
            # 如果启用自动保存，保存历史记录
            if self.auto_save:
                self._save_history()
            
            return True
        except Exception as e:
            print(f"Error importing history: {str(e)}")
            return False
    
    def save(self) -> bool:
        """
        手动保存历史记录
        
        Returns:
            bool: 是否保存成功
        """
        return self._save_history()
    
    def set_auto_save(self, auto_save: bool) -> None:
        """
        设置是否自动保存
        
        Args:
            auto_save: 是否自动保存
        """
        self.auto_save = auto_save
    
    def set_max_count(self, max_count: int) -> None:
        """
        设置最大记录数
        
        Args:
            max_count: 最大记录数
        """
        if max_count > 0:
            self.max_count = max_count
            
            # 如果当前记录数超过最大数量，删除最早的记录
            while len(self.history) > self.max_count:
                self.history.pop(0)
            
            # 如果启用自动保存，保存历史记录
            if self.auto_save:
                self._save_history()

# 创建全局实例
history = History()

def init_history(history_file: str = "history.json") -> History:
    """
    初始化全局历史记录实例
    
    Args:
        history_file: 历史记录文件路径
        
    Returns:
        History: 历史记录实例
    """
    global history
    history = History(history_file)
    return history

def add_record(original_text: str, summary: str, keywords: List[str], ratio: float, source: str = "text") -> str:
    """
    添加历史记录的快捷方法
    
    Args:
        original_text: 原始文本
        summary: 摘要文本
        keywords: 关键词列表
        ratio: 摘要比例
        source: 文本来源
        
    Returns:
        str: 记录ID
    """
    return history.add_record(original_text, summary, keywords, ratio, source)

def get_record(record_id: str) -> Optional[Dict[str, Any]]:
    """
    获取历史记录的快捷方法
    
    Args:
        record_id: 记录ID
        
    Returns:
        Optional[Dict[str, Any]]: 历史记录
    """
    return history.get_record(record_id)

def get_all_records() -> List[Dict[str, Any]]:
    """
    获取所有历史记录的快捷方法
    
    Returns:
        List[Dict[str, Any]]: 历史记录列表
    """
    return history.get_all_records()

def delete_record(record_id: str) -> bool:
    """
    删除历史记录的快捷方法
    
    Args:
        record_id: 记录ID
        
    Returns:
        bool: 是否删除成功
    """
    return history.delete_record(record_id)

def clear_history() -> bool:
    """
    清空历史记录的快捷方法
    
    Returns:
        bool: 是否清空成功
    """
    return history.clear_history()

def search_history(query: str) -> List[Dict[str, Any]]:
    """
    搜索历史记录的快捷方法
    
    Args:
        query: 搜索关键词
        
    Returns:
        List[Dict[str, Any]]: 匹配的历史记录列表
    """
    return history.search_history(query)